33.5 KB · ⇊ 9 parts · ⤓ Micron 33.5 KB · ⤓ HTML 90.1 KB

top

mwbaECMAScript (o mwbqES) è la mwbgspecifica tecnica di un mwbwlinguaggio di scripting, standardizzata e mantenuta da mwcaECMA International nell'mwcqECMA-262 ed ISO/IEC 16262. Le implementazioni più conosciute di questo linguaggio (spesso definite come dialetti) sono mwcgJavaScript, mwcwJScript e mwdaActionScript che sono entrati largamente in uso, inizialmente, come linguaggi mwdqlato client nello mwdgsviluppo web.

• Storia

• Versioni

• Quarta Edizione (abbandonata)

• Quinta Edizione

• Sesta Edizione - ECMAScript 2015

• Settima Edizione - ECMAScript 2016

• Ottava Edizione - ECMAScript 2017

• Nona Edizione - ECMAScript 2018

• Decima Edizione - ECMAScript 2019

• Undicesima Edizione - ECMAScript 2020

• Dodicesima edizione – ECMAScript 2021

• Conformità

• Browser web

• Implementazioni lato server

• Note

• Voci correlate

• Collegamenti esterni

Le specifiche definite da ECMAScript sono delle specifiche standardizzate di un linguaggio sviluppato da mwegBrendan Eich di mwewNetscape. Inizialmente era chiamato "Mocha", più tardi LiveScript e solo in ultimo JavaScript.cite-ref-1[1] Nel dicembre del 1995, la mwgaSun Microsystems insieme a Netscape annunciarono JavaScript attraverso un comunicato stampa.cite-ref-2[2] Nel marzo del 1996, mwhqNetscape Navigator 2.0 veniva distribuito diventando il primo browser a supportare JavaScript.

Grazie all'enorme successo di JavaScript come linguaggio client-side, mwhwMicrosoft sviluppò una versione differente ma compatibile del linguaggio chiamandolo mwiaJScript per evitare problemi di copyright. JScript implementava nuovi metodi per il calcolo della data per risolvere in parte i problemi dovuti all'anno 2000 che affliggevano JavaScript in quanto la classe Date era basata sull'omonima classe di Java.cite-ref-3[3] JScript fu incluso quindi in mwjqInternet Explorer 3.0, distribuito nell'Agosto del 1996.

Netscape consegnò JavaScript ad mwjwECMA International per il lavoro di standardizzazione e per fissare le specifiche. Così iniziò ECMA-262 nel novembre del 1996.cite-ref-4[4] Questa prima edizione fu adottata dall'Ecma General Assembly nel giugno del 1997 e diverse edizioni della standardizzazione sono state pubblicate da allora. Il nome "ECMAScript" fu un compromesso tra le organizzazioni coinvolte nella standardizzazione del linguaggio, specialmente Netscape e Microsoft le cui dispute dominavano la scena durante i primi tempi in cui questi standard nascevano. Eich difatti commentò che "ECMAScript è sempre stato un nome contrattato ma mai voluto che suonava molto come una malattia della pelle."cite-ref-5[5]

Mentre sia JavaScript che JScript mirano ad essere compatibili con le specifiche ECMAScript, provvedono a fornire allo stesso tempo funzioni aggiuntive non descritte dallo standard ECMA.cite-ref-6[6]

Sono state pubblicate finora 15 edizioni dell'ECMA-262. Dal 2015 la pubblicazione avviene con una cadenza annuale, per questo le edizioni hanno nel nome anche il riferimento all'anno di distribuzione sul mercato.

| Edizione | Data di pubblicazione | Nome | Cambiamenti rispetto all'edizione precedente | Redattore |

|---|---|---|---|---|

| 1 | Giugno 1997 [ 7 ] | | Prima edizione | Guy L. Steele, Jr. |

| 2 | Giugno 1998 [ 8 ] | | Cambi editoriali per mantenere le specifiche concordanti con l'ISO/IEC 16262 | Mike Cowlishaw |

| 3 | Dicembre 1999 [ 9 ] | | Aggiunte le espressioni regolari , miglior gestione delle stringhe, nuovi comandi di controllo, gestione del try/catch, formattazione per output numerici ed altri miglioramenti. | Mike Cowlishaw |

| 4 | Abbandonato | | La quarta edizione è stata abbandonata per delle diversità di idee a riguardo della complessità del linguaggio. Molte delle feature che furono proposte per la quarta versione sono state del tutto scartate mentre altre sono state riproposte nella versione 6. | |

| 5 | Dicembre 2009 | | Aggiunge lo "strict mode" inteso a provvedere un più completo controllo di errori e a scoraggiare gli sviluppatori ad incappare in errori. Chiarifica molte ambiguità introdotte nella terza versione. Aggiunge anche alcune feature come i getters e i setters, la libreria per il supporto a JSON e la reflection sulle proprietà degli oggetti. [ 10 ] | Pratap Lakshman, Allen Wirfs-Brock |

| 5.1 | Giugno 2011 | | Questa edizione è stata creata per allineare la precedente allo standard internazionale ISO/IEC 16262:2011. | Pratap Lakshman, Allen Wirfs-Brock |

| 6 | Giugno 2015 [ 11 ] | ECMAScript 2015 (ES2015) | La sesta edizione, conosciuta come ECMAScript 2015 [ 12 ] ma anche come "Harmony", apporta modifiche sintattiche significative che aprono la porta ad applicazioni più complesse, includendo classi e moduli definendoli semanticamente come lo "strict mode" in ECMAScript 5. Altre nuove features sono diversi iteratori, for/of loop, Python-style generators e generator expression, arrow functions, binary data, typed arrays, collections (maps, sets e weak maps), promises, miglioramenti delle funzioni matematiche, reflection e proxies (metaprogrammazione per virtual objects). | Allen Wirfs-Brock |

| 7 | Giugno 2016 | ECMAScript 2016 (ES2016) | La settima edizione, nota anche con il nome di ECMAScript 2016, è di fatto un assestamento dei cambiamenti introdotti nella precedente edizione. Introduce comunque due novità: l'operatore esponente (**) e Array.prototype.includes. | Brian Terlson |

| 8 | Giugno 2017 | ECMAScript 2017 (ES2017) | vedi Ottava Edizione - ECMAScript 2017 | Brian Terlson |

| 9 | Giugno 2018 | ECMAScript 2018 (ES2018) | vedi Nona Edizione - ECMAScript 2018 | Brian Terlson |

| 10 | Giugno 2019 | ECMAScript 2019 (ES2019) | vedi Decima Edizione - ECMAScript 2019 | Brian Terlson, Bradley Farias, Jordan Harband |

| 11 | Giugno 2020 | ECMAScript 2020 (ES2020) | vedi Undicesima Edizione - ECMAScript 2020 | Jordan Harband, Kevin Smith |

| 12 | Giugno 2021 | ECMAScript 2021 (ES2021) | vedi Dodicesima edizione - ECMAScript 2021 | Jordan Harband, Shu-yu Guo, Michael Ficarra, Kevin Gibbons |

| 13 | Giugno 2022 | ECMAScript 2022 (ES2022) | | Shu-yu Guo, Michael Ficarra, Kevin Gibbons |

| 14 | Giugno 2023 | ECMAScript 2023 (ES2023) | | Shu-yu Guo, Michael Ficarra, Kevin Gibbons |

| 15 | Giugno 2024 | ECMAScript 2024 (ES2024) | | Shu-yu Guo, Michael Ficarra, Kevin Gibbons |

| 16 | (in attesa) | ECMAScript 2025 (ES2025) | (in attesa) | (in attesa) |

Nel giugno 2004, ECMA International pubblicò lo standard ECMA-357, definendo un'estensione di ECMAScript, conosciuta come ECMAScript per XML (E4X). Ecma definì anche un "Compact Profile" per ECMAScript (conosciuto come ES-CP o ECMA 327) ideato per dispositivi dalle risorse limitate, che venne ritirato nel 2015.cite-ref-es-cp-withdrawn-13-0[13]

La quarta edizione proposta di ECMA-262 (ECMAScript 4 o ES4) sarebbe stata la prima major update di ECMAScript dalla terza edizione pubblicata nel 1999. L'uscita delle specifiche (insieme alle referenze per l'implementazione) era inizialmente prevista per ottobre 2009 ed infatti un'introduzione al linguaggio fu pubblicata dal gruppo di lavoro il 23 ottobre 2007.cite-ref-14[14]

Ad agosto 2008, fu presa la decisione di ridimensionare la quarta edizione di ECMAScript e accorparla al progetto ECMAScript Harmony. Le novità in discussione per Harmony erano:

• mw1gclassi

• un sistema di mw2amodularizzazione

• annotazione di tipi opzionale e mw2gtipizzazione statica, probabilmente usando un sistema di tipi strutturale

• generatori e mw3giteratori

• assegnamento destrutturato

• mw4gtipi di dati algebrici

L'intento di queste caratteristiche era in parte quello di facilitare lo sviluppo di software complessi con grandi gruppi di lavoro alle spalle e di permettere di eliminare alcune caratteristiche dinamiche del linguaggio per migliorare le prestazioni. Per esempio, Tamarin (la macchina virtuale per mw5aActionScript sviluppata e distribuita open source da Adobe) è dotata di compilazione JIT (mw5qjust-in-time).

Oltre all'introduzione di nuove features, nella quarta edizione fu proposto di correggere diversi bug dell'edizione precedentecite-ref-15[15]cite-ref-16[16]. Queste correzioni trovarono quindi posto nella quinta edizione

I lavori per quest'edizione iniziarono dopo aver completato le specifiche dell'edizione Compact Profile e continuarono approssimativamente per 18 mesi in cui i progressi erano lenti nel coniugare le idee di Netscape su JavaScript 2 con l'implementazione pratica di JScript di Microsoft. Ci furono anche diversi dibattiti avvenuti pubblicamente su dei blog tra Eich, che sarebbe diventato più tardi il CTO della Mozilla Foundation e Chris Wilson dipendente Microsoft, responsabile per l'architettura di Internet Explorer. Wilson asseriva che i cambiamenti proposti per il nuovo standard che non erano completamente retrocompatibili con le versioni precedenti del linguaggio avrebbero "rotto il web"cite-ref-17[17] e che chi si era opposto era stato messo in secondo pianocite-ref-18[18]. Eich rispose dando del bugiardo al suo detrattore e lo sfidò chiedendo pubblicamente di dimostrargli specifici esempi di incompatibilitàcite-ref-19[19].

mw-gYahoo!, mw-wMicrosoft, mwaqaGoogle e altri dissidenti della quarta edizione di ECMAScript formarono il loro "sottocomitato" per progettare un update di ECMAScript 3 un po' meno ambizioso, chiamandolo provvisoriamente ECMAScript 3.1. Questa edizione si sarebbe concentrata sulla sicurezza e sugli aggiornamenti delle librerie con un punto di riguardo sulla compatibilità.

Dopo il dibattito sopra descritto, entrambi i team di ES 3.1 ed ES 4 si accordarono con un compromesso: si sarebbe lavorato sulle due edizioni in parallelo e con i due team coordinati per essere sicuri che ES 3.1 sarebbe rimasto strettamente un sottoinsieme di ES 4 (sia nella semantica che nella sintassi).

Tuttavia, le differenti filosofie di sviluppo crearono ripetutamente incompatibilità tra i lavori dei due team e sembrava chiaro che i team che non erano d'accordo con l'ECMAscript 4 non l'avrebbero mai implementato. Dopo circa un anno dalla frattura sulla visione del futuro di ECMAScript, all'Ecma Technical Committee 39cite-ref-20[20], nel luglio 2008, mwaqcBrendan Eich annunciò che i due team riuscirono ad accordarsi in un percorso comune, essenzialmente allineato sullo sviluppo della 3.1, successivamente rinominato Quinta Edizione.

Nell'aprile 2009 venne pubblicato la bozza finale della quinta edizione e fu finalizzata la versione definitiva nel mese di dicembrecite-ref-21[21].

Nel giugno 2011 venne pubblicata la revisione 5.1cite-ref-22[22].

La sesta edizione, conosciuta inizialmente come ECMAScript (ES6) ma rinominata successivamente ECMAScript 2015 fu pronta nel 2015cite-ref-23[23]. Questa edizione portò importanti ampliamenti alla sintassi, pensati per rendere più agevole la scrittura di applicazioni complesse, tra cui le nuove dichiarazioni delle classi (mwargmwarkclassmwaro mwarsFoomwarw mwar0{mwar4 mwar8...mwasa mwase}) e i moduli attraverso le istruzioni mwasimwasmimport e mwasqmwasuexport. Alcune altre novità sintattiche furono il nuovo iteratore mwasymwascformwasg mwask...mwaso mwassof, le funzioni a freccia (mwas0mwas4()mwas8 mwata=>mwate mwati{...}), i generatori in stile mwatmPython, Le parole chiave mwatqlet per dichiarare le variabili con mwatuvisibilità locale e mwatyconst dichiarare le costanti, dati binari, array tipizzati, nuove collections (maps, sets e WeakMap), mwatcpromises, miglioramenti a numeri e matematica, mwatgreflection, proxy e template string.cite-ref-24[24]cite-ref-25[25]

La settima edizione, ufficialmente ECMAScript 2016, fu pubblicata nel Giugno del 2016cite-ref-es2016-26-0[26]. Le maggiori novità includono il block-scoping per variabili e funzioni, gli assegnamenti destrutturati delle variabili, proper tail calls, operatore esponente (mwaug**) e le keyword mwaukawait, mwauoasync per la programmazione asincrona. cite-ref-es2016-26-1[26]cite-ref-27[27] ottava-edizione

L'ottava edizione, nota ufficialmente con il nome di ECMAScript 2017cite-ref-28[28], è stata completata e pubblicata nel Giugno del 2017. Le nuove funzionalità proposte includono concurrency ed atomics, zero copy binary transfer, altri miglioramenti nell'ambito matematico, integrazione sintattica con le promise, observable streams, SIMD, migliore metaprogrammazione con le classi, overload degli operatori e molto altro. nona-edizione

La nona edizione, nota come ECMAScript 2018 è stata pubblicata nel giugno del 2018cite-ref-29[29]. Vengono introdotte le iterazioni asincrone (mwav8for await(i of var)), le Promise ora hanno i metodi mwawathen(), mwawecatch() (se vanno in errore) e mwawifinally(), la spread syntax per i parametri delle funzioni (mwawqfunction pippo(foo, ...bar)). Corpose novità riguardano l'uso delle mwawuregular expressioncite-ref-30[30]. decima-edizione

La decima edizione, chiamata ECMAScript 2019 è stata resa pubblica nel giugno 2019cite-ref-31[31]. Le maggiori novità riguardano i metodi mwaxaArray.flatMap()cite-ref-32[32] e mwaxuObject.fromEntries()cite-ref-33[33]cite-ref-34[34]. undicesima-edizione

L'undicesima edizione, o ECMAScript 2020, è stata pubblicata nel giugno 2020cite-ref-35[35]. In aggiunta alle nuove funzioni, questa versione introduct un tipo primitivo mwayqBigInt per interi di dimensioni arbitrarie, l'operatore di coalescenza nullo, e l'oggettomwayythis globale .

I BigInt sono creati con il costruttore mwaygBigInto con la sintassi mwayk10n, dove la "n" è posizionata dopo il letterale del numero. I BigInt consentono la rappresentazione e la manipolazione di interi che vanno oltremwayoNumber.MAX_SAFE_INTEGER, mentre i tipi Numbers sono rappresentati da un valore mwaysIEEE 754 a precisione doppia da 64bit. Le funzioni incorporate in mwaywMath non sono compatibili con BigInts; per esempio l'esponenzianzione dei BigInt deve essere fatta con l'operatore mway0** invece di mway4Math.pow.

L'operatore di coalescenza nullo mwaza?? restituisce l'operando di destra quando l'operando di sinistra è mwazenull o mwaziundefined. Questo è in contrasto con l'operatore mwazm|| che restituirebbe mwazq"string" per tutti i valori mwazufalse come quelli rappresentati di seguito:

La concatenazione opzionale rende possibile accedere alle proprietà annidate di un oggetto senza avere un controllo AND a ogni livello.

Un esempio è mwazkconst zipcode = person?.address?.zipcode. Se una qualunque delle proprietà è non presente, mwazozipcode sarà mwazsundefined. dodicesima-edizione

La dodicesima edizione, o ECMAScript 2021, è stata pubblicata nel giugno 2021cite-ref-36[36]. Introduce il metodo mwaaireplaceAll per le stringhe; la nuova combinazione di promise mwaamPromise.any, che esegue il codice non appena la prima delle mwaaqpromise restituisce un valore. Introdotto anche mwaauAggregateError, un nuovo tipo di errore che permette di rappresentare più errori in una volta. Arrivano nuovi operatori logici di assegnazione: mwaay??=, mwaac&&=, mwaag||=; mwaakWeakRef crea una reference a un oggetto senza preservarlo dalla cancellazione del garbage collector e mwaaoFinalizationRegistry, che permette l'esecuzione di una callback quando un oggetto target viene cancellato dal garbage collector; è ora possibile usare i separatori per i numeri: mwaas1_000.

Nel 2010, mwaa4ECMA International iniziò lo sviluppo di un test per verificare la conformità allo standard ECMA 262 ECMAScript.

Chiamato Test262, questo test viene utilizzato per capire quanto le varie implementazioni di JavaScript siano conformi alle specifiche. Il test contiene migliaia di verifiche individuali, una per ogni requisito dei vari standard.

Lo sviluppo di Test262 è affidato all'ECMA Technical Committee 39 (TC39). Google e Microsoft hanno contribuito in modo importante allo sviluppo: entrambe hanno sviluppato migliaia dei test eseguiti dalla suite. Test262 consiste in mwabe38014 test. Il dato è aggiornato a Gennaio 2020.cite-ref-github-2020-37-0[37]. Le tabelle sottostanti mostrano la conformità degli engine JavaScript nelle applicazioni più diffuse.

| Engine | Browser | Conformità | Conformità | Conformità | Conformità |

|---|---|---|---|---|---|

| Engine | Browser | ES5 [ 38 ] | ES6 [ 39 ] | 2016+ [ 40 ] [ 41 ] | |

| V8 | Microsoft Edge 80 | 100% | 98% | 100% | |

| SpiderMonkey | Firefox 73 | 100% | 98% | 82% | |

| V8 | Google Chrome 80, Opera 67 | 100% | 98% | 100% | |

| JavaScriptCore (Nitro) | Safari 13 | 99% | 99% | 80% | |

| Engine | Server | Conformità | Conformità | Conformità | Conformità |

|---|---|---|---|---|---|

| Engine | Server | ES5 [ 38 ] | ES6 [ 39 ] | 2016+ [ 40 ] [ 41 ] | |

| V8 | Node.js 13.2 | 100% | 98% | 92% | |

cite-note-11. ↑ mwahsPaul Krill, mwahwmwah0JavaScript creator ponders past, future mwah4| Developer World, su mwah8infoworld.com, InfoWorld, 23 giugno 2008. mwaiaURL consultato il 31 ottobre 2013.

cite-note-22. ↑ mwaiqmwaiumwaiyPress Release, su mwaicwp.netscape.com. mwaigURL consultato il 31 ottobre 2013 mwaik(archiviato dall'mwaiourl originale il 16 settembre 2007).

cite-note-33. ↑ mwai4mwai8mwajaBrendan's Roadmap Updates: Popularity, su mwajeweblogs.mozillazine.org mwaji(archiviato dall'mwajmurl originale il 17 maggio 2008).

cite-note-44. ↑ mwajcmwajgmwajkPress Release, su mwajocgi.netscape.com. mwajsURL consultato il 31 ottobre 2013 mwajw(archiviato dall'mwaj0url originale il 3 dicembre 1998).

cite-note-55. ↑ mwakemwakimwakmWill there be a suggested file suffix for es4?, su mwakqmail.mozilla.org, 3 ottobre 2006. mwakuURL consultato il 31 ottobre 2013 mwaky(archiviato dall'mwakcurl originale il 21 giugno 2020).

cite-note-66. ↑ mwaksmwakwmwak0JScript VS JavaScript, su mwak4javascript.about.com, About.com, 25 novembre 2015. mwak8URL consultato il 1º marzo 2016 mwala(archiviato dall'mwaleurl originale il 26 novembre 2015).

cite-note-71. mwalumwalymwalcECMA-262, 2nd edition (mwalgmwalkPDF), su mwaloecma-international.org. mwalsURL consultato il 15 giugno 2022.

cite-note-82. mwal8mwamamwameECMA-262, 2nd edition (mwamimwammPDF), su mwamqecma-international.org. mwamuURL consultato il 15 giugno 2022.

cite-note-93. mwamkmwamomwamsECMA-262, 3th edition ECMAScript® 1999 Language Specification (mwamwmwam0PDF), su mwam4ecma-international.org. mwam8URL consultato il 15 giugno 2022.

cite-note-104. mwanmmwanqmwanuChanges to JavaScript, Part 1: EcmaScript 5, su mwanyyoutube.com, YouTube, 18 maggio 2009. mwancURL consultato il 31 ottobre 2013.

cite-note-115. mwansmwanwmwan0Itmwan4's official: ECMAScript 6 is approved | InfoWorld, su mwan8infoworld.com.

cite-note-126. mwaommwaoqmwaouECMAScript 2015 Language Specification – ECMA-262 6th Edition, su mwaoyecma-international.org.

cite-note-es-cp-withdrawn-1313. ↑ mwaoo2015-03-24 Meeting Notes. ESDiscuss. Also see mwaosEcma withdrawn Standards. ECMA.

cite-note-1414. ↑ mwao8mwapamwapeProposed ECMAScript 4th Edition – Language Overview (mwapimwapmPDF), su mwapqecmascript.org, 23 ottobre 2007 mwapu(archiviato dall'mwapyurl originale il 13 luglio 2010).

cite-note-1515. ↑ mwapoJohn Resig, mwapsmwapwJohn Resig – Bug Fixes in JavaScript 2, su mwap0ejohn.org. mwap4URL consultato il 31 ottobre 2013.

cite-note-1616. ↑ mwaqimwaqmmwaqqCompatibility Between ES3 and Proposed ES4 (mwaqumwaqyPDF), su mwaqcecmascript.org. mwaqgURL consultato il 31 ottobre 2013 mwaqk(archiviato dall'mwaqourl originale il 24 luglio 2014).

cite-note-1717. ↑ mwaq4mwaq8mwaraECMAScript 3 and Beyond – IEBlog – Site Home – MSDN Blogs, su mwareblogs.msdn.com, 30 ottobre 2007. mwariURL consultato il 31 ottobre 2013.

cite-note-1818. ↑ mwarymwarcmwargWhat I think about ES4. - Albatross! - Site Home – MSDN Blogs, su mwarkblogs.msdn.com, 31 ottobre 2007. mwaroURL consultato il 31 ottobre 2013.

cite-note-1919. ↑ mwar4mwar8mwasaOpen letter to Chris Wilson, su mwasebrendaneich.com, Brendan Eich, 31 ottobre 2007. mwasiURL consultato il 31 ottobre 2013 mwasm(archiviato dall'mwasqurl originale il 16 settembre 2011).

cite-note-2020. ↑ mwasgmwaskmwasoEcma Technical committee 39, su mwassecma-international.org. mwaswURL consultato il 7 giugno 2022.

cite-note-2121. ↑ mwatamwatemwatiECMA-262, 5th edition ECMAScript® 2009 Language Specification (mwatmmwatqPDF), su mwatuecma-international.org. mwatyURL consultato il 14 giugno 2022.

cite-note-2222. ↑ mwatomwatsmwatwECMA-262, 5.1 edition ECMAScript® 2009 Language Specification (mwat0mwat4PDF), su mwat8ecma-international.org. mwauaURL consultato il 14 giugno 2022.

cite-note-2323. ↑ mwauqmwauumwauyECMA-262, 6th edition, June 2015 ECMAScript® 2015 Language Specification, su mwaucecma-international.org. mwaugURL consultato il 4 giugno 2022.

cite-note-2424. ↑ mwauw(mwau0mwau4EN) mwau8mwava5 Great Features in EcmaScript 6 (ES6 Harmony) - Wintellect, in mwaveWintellect, 24 marzo 2014. mwaviURL consultato il 19 marzo 2018 mwavm(archiviato dall'mwavqurl originale il 22 luglio 2017).

cite-note-2525. ↑ mwavg(mwavkmwavoEN) mwavsmwavwECMAScript 6 (ES6): What's New In The Next Version Of JavaScript, in mwav0Smashing Magazine, 28 ottobre 2015. mwav4URL consultato il 19 marzo 2018.

cite-note-es2016-2626. ↑ mwawqmwawumwawyECMAScript 2016 Language Specification, su mwawcecma-international.org, mwawgECMA International, June 2016.

cite-note-2727. ↑ mwawwMichael Saboff, mwaw0mwaw4ECMAScript 6 Proper Tail Calls in WebKit, su mwaw8WebKit, 23 maggio 2016. mwaxaURL consultato l'11 aprile 2019.

cite-note-2828. ↑ mwaxqmwaxumwaxyECMA-262, 8th edition, June 2017 ECMAScript® 2017 Language Specification, su mwaxcecma-international.org. mwaxgURL consultato il 4 giugno 2022.

cite-note-2929. ↑ mwaxwmwax0mwax4ECMA-262, 9th edition, June 2018 ECMAScript® 2018 Language Specification, su mwax8ecma-international.org. mwayaURL consultato il 2 giugno 2022.

cite-note-3030. ↑ mwayqmwayumwayyWhatmwayc's New in ES2018 — SitePoint, su mwaygsitepoint.com.

cite-note-3131. ↑ mwaywmway0mway4ECMA-262, 10th edition, June 2019 ECMAScript® 2019 Language Specification, su mway8ecma-international.org. mwazaURL consultato il 4 giugno 2022.

cite-note-3232. ↑ mwazqmwazumwazyFunctional pattern: flatMap, su mwazc2ality.com.

cite-note-3333. ↑ mwazsmwazwmwaz0ES proposal: `Object.fromEntries()`, su mwaz42ality.com.

cite-note-3434. ↑ mwa0imwa0mmwa0qECMAScript® 2019 Language Specification, su mwa0uecma-international.org.

cite-note-3535. ↑ mwa0kmwa0omwa0sECMA-262, 11th edition, June 2020 ECMAScript® 2020 Language Specification, su mwa0wecma-international.org. mwa00URL consultato il 4 giugno 2022.

cite-note-3636. ↑ mwa1emwa1imwa1mECMA-262, 12th edition, June 2021 ECMAScript® 2021 Language Specification, su mwa1qecma-international.org. mwa1uURL consultato il 2 giugno 2022.

cite-note-github-2020-3737. ↑ mwa1kmwa1omwa1stc39/test262, su mwa1wGitHub, 24 gennaio 2020. mwa10URL consultato il 29 gennaio 2020.

cite-note-kangax5-387. mwa2m(mwa2qmwa2uEN) mwa2ymwa2cECMAScript 5 compatibility table, su mwa2gkangax.github.io. mwa2kURL consultato l'8 novembre 2018 mwa2o(archiviato dall'mwa2surl originale il 19 novembre 2018).

cite-note-kangax6-398. mwa3e(mwa3imwa3mEN) mwa3qmwa3uECMAScript 6 compatibility table, su mwa3ykangax.github.io. mwa3cURL consultato l'8 novembre 2018 mwa3g(archiviato dall'mwa3kurl originale il 17 novembre 2018).

cite-note-kangax2016plus-409. mwa38(mwa4amwa4eEN) mwa4imwa4mECMAScript 2016+ compatibility table, su mwa4qkangax.github.io. mwa4uURL consultato l'8 novembre 2018 mwa4y(archiviato dall'mwa4curl originale il 24 novembre 2018).

cite-note-punteggio-4110. Punteggio che racchiude tutti i test di conformità dalla ES2016 alla ES2019

• mwa5aActionScript

• mwa5iDART (linguaggio)

• mwa5qDocument Object Model

• mwa5yJavaScript

• mwa5gJScript

• mwa5oQML (linguaggio di programmazione)

• mwa5wTypeScript

• citereffoldoc(EN) Denis Howe, ECMAScript, in Free On-line Dictionary of Computing. Disponibile con licenza mwa6aGFDL

• mwa6i(EN) Sito ufficiale - ECMAScript, su ecmascript.org. URL consultato il 1º marzo 2016 (archiviato dall'url originale il 18 maggio 2016).